home *** CD-ROM | disk | FTP | other *** search
/ PCMania 73 / PCMania CD73_1.iso / pcmania / render73 / Taller / PRUEBA1.POV < prev    next >
Text File  |  1998-10-06  |  16KB  |  349 lines
  1. /* ESta es la tabla de paneles rectangulares
  2.  
  3. panelR2x2_2y4
  4. panelR2x2_2y4y4
  5. panelR2x2_ventana10
  6. panelR2x2_ventana11
  7.  
  8. panelR3x1_2y4            panelR3x2_2y4      
  9. panelR3x1_2y4y16         panelR3x2_2y4y16   
  10. panelR3x1_2y4y32         panelR3x2_2y4y32   
  11. panelR3x1_puerta10       panelR3x2_2y4y16y32
  12. panelR3x1_puerta11       panelR3x2_puerta10 
  13. panelR3x1_ventana10      panelR3x2_puerta11 
  14. panelR3x1_ventana11      panelR3x2_puerta12 
  15.                          panelR3x2_puerta13 
  16.                          panelR3x2_ventana10
  17.                          panelR3x2_ventana11
  18.                          panelR3x2_ventana12
  19.                          panelR3x2_ventana13
  20.  
  21.  
  22. panelR4x1_2y4            panelR4x2_2y4           panelR4x3_2y4      
  23. panelR4x1_puerta10       panelR4x2_2y4y4         panelR4x3_2y4y4    
  24. panelR4x1_puerta11       panelR4x2_2y4y16        panelR4x3_2y4y16   
  25. panelR4x1_ventana10      panelR4x2_2y4y32        panelR4x3_2y4y32   
  26. panelR4x1_ventana11      panelR4x2_2y4y16y32     panelR4x3_2y4y16y32
  27.                          panelR4x2_ventana20     panelR4x3_puerta20 
  28.  
  29. fin de la lista */
  30.  
  31.  
  32.  
  33.  
  34. #include "colors.inc"
  35.  
  36. camera {    //prueba 1 de camara para portada
  37.    location <400, 900, -1450>
  38.    direction <0.0, 0.0, 1>
  39.    up  <0.0, 1.0, 0.0>
  40.    right <1.33,0.0, 0.0>                    
  41.    look_at <200,200,0> 
  42. //orthographic
  43.    } 
  44.   
  45. light_source {<-50000,60000,-50000> color White}
  46. light_source {<30000,40000,-50000> color White}
  47.  
  48.  
  49. #declare madera1=texture{pigment{Brown}}
  50. #declare madera2=texture{pigment{rgb<1,.7,.2>}}
  51. #declare madera3=texture{pigment{rgb<9,.5,.05>}}
  52. #declare piedra1=texture{pigment{Cyan}}
  53. #declare piedra2=texture{pigment{Cyan}}
  54. #declare pared=texture{pigment{Orange}}
  55. #declare cristal1=texture{pigment{Maroon}}
  56. #declare hierro1=texture{pigment{Blue}}
  57. #declare hierro2=texture{pigment{Green}}
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64. #include "castlib1.inc"
  65. #declare R=seed(1645);
  66. //#declare R=seed(11645);
  67. //#declare R=seed(14226);
  68.  
  69. /*el siguiente array guarda una lista de series. El primer indice es el numero de estilo y los elementos apuntados
  70.   por el segundo indice son campos del registro del estilo indicado en el primer indice. Dentro de este registro, el
  71.   primer campo indica el numero de series que que definen el estilo, el siguiente indica (si no es 255), que serie
  72.   debe ser utilizada obligatoriamente para el primer piso y los campos restantes son series que pueden ser utilizadas
  73.   en los pisos superiores (y tambien en el primero, si el segundo campo no =255).
  74.   */
  75. #declare lista_estilos=array[1][10]{
  76.         {1,255,0,0,0,0,0,0,0,0}
  77.         }
  78.         
  79. /* el siguiente array guarda los paneles segun series cuyos elementos forman un estilo dado; hay
  80.    series que dan preferencia a las puertas de piedra, otras a las de madera, otras a las zonas en
  81.    blanco, etc */
  82. #declare serie_paneles=array[1][15]
  83. // aqui se guarda el ancho de cada panel de cada serie
  84. #declare ancho_paneles=array[1][15]{
  85.         {100,200,100,100,100,100,100,100,0,0,0,0,0,0,0}
  86.         }
  87. /*el primer elemento de cada par guarda el numero total de paneles de la serie, el segundo el punto
  88.   de la misma donde comienzan las ventanas y el tercero el punto donde comienzan las puertas (el
  89.   indice 0 siempre son vigas). El cuarto guarda los flags de datos de la serie que se organizan
  90.   como sigue:
  91.   128=no deben generarse puertas si no estamos en el primer piso
  92.    64=si se permiten puertas, se pondran siempre balcones. De lo contrario puede colocarse una
  93.       escalera si la altura total no excede de 8
  94.   Por ·ltimo, el 5 campo guarda la altura en Y de cada serie 
  95.    */
  96. #declare datos_series=array[1][5]{
  97.         {6,4,5,128,300}
  98.         }        
  99. /*RUSTICA1 (paneles de 3 alto, predominio de 1 de ancho, puertas y ventanas madera, con ancho 2 no
  100.  hay adornos) */
  101. #declare serie_paneles[0][0]=panelR3x1_2y4   
  102. #declare serie_paneles[0][1]=panelR3x2_2y4
  103. #declare serie_paneles[0][2]=panelR3x1_2y4y16
  104. #declare serie_paneles[0][3]=panelR3x1_2y4y32
  105. #declare serie_paneles[0][4]=panelR3x1_ventana11
  106. #declare serie_paneles[0][5]=panelR3x1_puerta10
  107. //#declare serie_paneles[0][6]=panelR3x1_puerta11
  108.  
  109.  
  110. #declare muro=array[100]        //array global con los datos devueltos por la macro pared
  111. #local a=0;
  112. #while(a<100)
  113.         #declare muro[a]=0;
  114.         #local a=a+1;
  115. #end
  116.  
  117.  
  118. //Esta macro devuelve el numero aleatorio de un panel del ancho escogido dentro de la serie
  119. //el tercer parametro se usa para excluir puertas o puertas y ventanas, si asi lo deseamos
  120. #macro EscogePanel(serie, ancho, limite)
  121.         #local num_panel=int(rand(R)*limite);
  122.         #while (ancho_paneles[serie][num_panel]!=ancho)
  123.                 #warning concat("num_panel ",str(num_panel,0,0),"  ancho= ",
  124.                                 str(ancho_paneles[serie][num_panel],0,0),"  ")
  125.                 #local num_panel=num_panel+1;
  126.                 #if (num_panel>limite) #local num_panel=0; #end
  127.         #end        
  128.         num_panel
  129. #end
  130.  
  131. //esta macro escoge los paneles para el muro en curso
  132. #macro CreaMuro(limite_largo_muro, npiso, serie)
  133.         #local contador_largo_muro=0;           //inicializamos contador de longitud del muro
  134.         #local ancho=0;
  135.         #local num_panel=0;                     //numero de panel en curso                     
  136.         #local numero_paneles=datos_series[serie][0];  //num. paneles de la serie
  137.         #local limite=0;                        //esta variable se usa como limite para el Rand
  138.         #local ventanas=datos_series[serie][2]; //aqui empiezan las ventanas de la serie
  139.         #local puertas=datos_series[serie][2]; //aqui empiezan las puertas de la serie
  140.         #local flags=datos_series[serie][3];
  141.         #local distancia_ultima_puerta=255;     //si = 255, aun no se ha colocado ninguna puerta
  142. // en primer lugar comprobamos si las puertas estan permitidas o no
  143.         #if (datos_series[serie][3]>=128 & npiso>0)
  144.                 #local limite=puertas;
  145.         #else        
  146.                 #local limite=numero_paneles;
  147.         #end
  148.         #local elemento=0;
  149.         #while (contador_largo_muro<limite_largo_muro)
  150.                 #if (limite_largo_muro - contador_largo_muro = 100)
  151.                         // el primer elemento de la serie siempre tiene un largo de 1
  152.                         #declare muro[elemento]=0;
  153.                         #local contador_largo_muro=contador_largo_muro+100;
  154.                 #else
  155.                         #local num_panel=int(rand(R)*limite);
  156.                         #if (limite_largo_muro - contador_largo_muro < ancho_paneles[serie][num_panel])
  157.                         // el segundo elemento de la serie siempre tiene un largo de 2
  158.                                 #declare muro[elemento]=1;
  159.                                 #local contador_largo_muro=contador_largo_muro+200;
  160.                         #else   
  161. /*Si se permite colocar puertas y rand ha devuelto un panel con puertas, se llega aqui. Y aqui, si aun no
  162.   se ha colocado ninguna puerta o si la distancia entre la nueva y la ·ltima es mayor de 600, entonces se 
  163.   permite poner una puerta. */
  164.                                 #if(num_panel>=puertas)
  165.                                         #if(distancia_ultima_puerta=255 | ((distancia_ultima_puerta!=255)
  166.                                              & (contador_largo_muro - distancia_ultima_puerta > 600)))
  167.                                                 #local distancia_ultima_puerta=contador_largo_muro;
  168.                                         #else
  169. //De lo contrario se fuerza la colocaci≤n de un panel de ancho 1 de la serie, excluyendo los de puertas
  170.                                                 #declare num_panel=EscogePanel(serie, 100, puertas);
  171.                                         #end
  172.                                 #end
  173.                         #declare muro[elemento]=num_panel;
  174.                         #local ancho=ancho_paneles[serie][num_panel];
  175.                         #local contador_largo_muro=contador_largo_muro + ancho;
  176.                         #end
  177.                 #end
  178.         #local elemento=elemento+1;
  179.         #end
  180.         #declare muro[elemento]=255;      //marca de fin de pared
  181. #end
  182.  
  183. /*
  184. //devuelve la altura del panel que vamos a emplear para el piso en curso
  185. #macro determinar_altura(altura, suelo)
  186.         #if (altura-suelo=3 || altura-suelo=6) altura=3
  187.         #else #if (altura-suelo>=8) altura
  188.  
  189.  
  190. */
  191.  
  192. /*Esta pov-macro es la encargada de construir las casas. Estas seran generadas segun los
  193.   valores que se pasan a la macro en sus parametros. Las variables de la serie move guardan
  194.   valores para trasladar a la casa a lo largo de los ejes a los que referencian. Y los demas...
  195.   
  196.   estilo: Se usa para determinar el tipo de paneles que se emplean en la casa. 
  197.   anchura: Anchura en metros en X
  198.   Largo: Profundidad en el eje Z (la altura exacta no es relevante y siempre empleamos pisos de 4 y 3
  199.          metros de altura)
  200.   npisos: Num. de pisos de la casa
  201.   Lados: Desde cualquier punto de vista unicamente podremos ver dos lados de cualquier casa. Por tanto
  202.          usamos esta variable para indicar los lados que son visibles. Los otros no se construyen. (Los
  203.          lados visibles se determinan dependiendo de la posici≤n de la casa con respecto a la camara).
  204.          Si +128=lado +Z visible, de lo contrario vemos el +Z y si +64 entonces vemos el lado +X, de lo
  205.          contrario veremos el otro. (Ver el lado -Z, significa que, por ejemplo, estamos en -5Z y miramos
  206.          hacia Z=0).
  207.   puertas: Se usa para indicar los lados de la casa donde iran las puertas y cuantas habra.
  208.   Salientes: Indica si la casa tendra salientes y donde estaran estos
  209.   colgantes: Idem. en el caso de las estructuras colgantes.
  210.   
  211.   La pov-macro utiliza el array bidimensional citymap para determinar el espacio de que disponen
  212.   las casas y evitar que estas se superpongan y tambien para averiguar las zonas de suelo sobre
  213.   las que se pueden poner habitantes */
  214.  
  215. #macro MakeHouse(estilo, anchura, largo, npisos, lados)
  216.                  /* puertas, salientes, colgantes, moveX, moveY, moveZ) */
  217. //#macro MakeHouse(estilo)
  218.         #local baseY=0;         //Contador de altura. La base del piso actual
  219.         #local cpiso=0;         //comenzamos con el primer piso
  220.         #local var1=0;          //variable local multiproposito
  221.         #local var2=0;          //otra mas
  222.         #local altura=0;        //la altura del primer piso es 0
  223.     #while(cpiso<npisos)
  224.         #if(cpiso=0 & lista_estilos[estilo][1]!=255)
  225.                 #local serie=lista_estilos[estilo][1];
  226.         #else                
  227.         //escogemos aleatoriamente alguna de las series del estilo de la casa
  228.                 #local var1=lista_estilos[estilo][0];
  229.                 #local var2=int(rand(R*var1));
  230.                 #local serie=lista_estilos[estilo][var2+2];
  231. //                #warning concat("serie ",str(serie,0,0)," valor rand= ", str(var2,0,0))
  232.         #end
  233.         #local tlado=lados;     //var. temporal que guarda los lados visibles de la casa
  234.         #local pos_X=0;         //inicializar contador posicional
  235.         #local elem=0;          //contador para muro
  236.         CreaMuro(anchura, cpiso, serie)
  237.         union{
  238.                 #while( muro[elem]!=255)
  239.                         object{serie_paneles[estilo][muro[elem]] translate<pos_X,altura,0>}        
  240.                         #local pos_X=pos_X+ancho_paneles[estilo][muro[elem]];
  241.                         #local elem=elem+1;
  242.                 #end                        
  243.         #if (tlado>64) rotate y*180 translate<anchura,0,largo> #local tlado=tlado-128 #end
  244.         }
  245.         #local pos_X=0;           //inicializar contador posicional
  246.         #local elem=0;
  247.         CreaMuro(largo, cpiso, estilo)
  248.         union{
  249.                 #while( muro[elem]!=255)
  250.                         object{serie_paneles[estilo][muro[elem]] translate<pos_X,altura,0>}        
  251.                         #local pos_X=pos_X+ancho_paneles[estilo][muro[elem]];
  252.                         #local elem=elem+1;
  253.                 #end                        
  254.         #if (tlado>32)
  255.                 rotate y*-90 translate<anchura,0,0>
  256.         #else
  257.                 rotate y*90 translate<0,0,largo>
  258.         #end                
  259.         }
  260.     #local cpiso=cpiso+1;
  261. //para el siguiente piso, colocamos los paneles a la altura adecuada
  262.     #local altura=altura+datos_series[serie][4];
  263.     #end
  264. /*ya se han creado los pisos, el siguiente paso es crear el tejado y el panel visible (como en el caso de
  265.   los pisos, lo no visible no se dibuja. El panel visible es, por supuesto, el que acompa±a al panel Z visible */
  266. //     union{MakeTejado(anchura, largo, lados) translate<0,altura,0>}
  267. #end
  268.  
  269.  
  270.  
  271. /*Aqui sigue la macro que construye los tejados. Emplea las siguientes estructuras
  272. //ESTRUCTURAS PARA TEJADOS DE 26.625 grados
  273. //paredes para tejados con esa inclinación
  274. paredT4x2_completa_izq      paredT4x2_completa_der
  275. paredT4x2_ventana_izq       paredT4x2_ventana_der
  276.  
  277. //picos de tejados de ese tipo
  278.             pico_tejado_4x2
  279.             pico_tejado_4x2_ventana1
  280.             pico_tejado_4x2_ventana2
  281.  
  282. //los tejados con 26.625 grados de inclinación
  283. tejado26_izq_3metros        tejado26_der_3metros    
  284. tejado26_izq_3metros_final  tejado26_der_3metros_final
  285. tejado26_izq_4decim         tejado26_der_4decim
  286. tejado26_izq_4decim_final   tejado26_der_4decim_final
  287. tejado26_izq_2metros        tejado26_der_2metros
  288. tejado26_izq_2metros_final  tejado26_der_2metros_final
  289.  
  290. //ESTRUCTURAS PARA TEJADOS DE 45 grados
  291. //paredes
  292. paredT4x4_completa_izq      paredT4x4_completa_der
  293. paredT4x4_puerta_izq        paredT4x4_puerta_der
  294. //tejados
  295. tejado45_izq_3metros        tejado45_der_3metros
  296. tejado45_izq_3metros_final  tejado45_der_3metros_final
  297. tejado45_izq_4decim         tejado45_der_4decim
  298. tejado45_izq_4decim_final   tejado45_der_4decim_final
  299. tejado45_izq_2metros        tejado45_der_2metros
  300. tejado45_izq_2metros_final  tejado45_der_2metros_final
  301. //los picos
  302.             pico_tejado_4x4
  303.             pico_tejado_4x4_puerta1
  304.             pico_tejado_4x4_puerta2     */
  305.  
  306. #macro MakeTejado(anchura, largo, lados)
  307. /*lo primero es decidir que tipo de tejado se va a emplear, si el de 26 o el de 45 grados.
  308.   Si el edificio tiene un ancho frontal superior a 10 metros usaremos las piezas de 45 */
  309.      #warning concat("anchura ",str(anchura,0,0),"\n")
  310.      #if(anchura<=1000)        
  311. /*los algoritmos para crear tejado dependen del ancho del mismo debido a las "pocas"
  312.   piezas definidas */          
  313.           #switch(anchura)
  314.                #case (600)
  315.                     #warning concat("pase por aqui \n")
  316.                     object{paredT4x2_completa_izq}
  317.                     object{panelR4x2_2y4 translate<200,0,0>}
  318.                     object{viga4x1_2 translate<400,0,0>}
  319.                     object{paredT4x2_completa_der translate<200,0,0>}
  320.                     object{paredT4x2_completa_izq translate<100,200,0>}
  321.                     object{paredT4x2_completa_der translate<100,200,0>}
  322.  
  323.                #break
  324.           #end
  325.      #end
  326. #end
  327.                
  328. /*  #if (lados>64) rotate y*180 translate<anchura,0,largo> #local tlado=tlado-128 #end */
  329.   
  330.  
  331.  
  332.  
  333.  
  334.  
  335. //EXPERIMENTOS
  336. /*
  337. union{MakeHouse(0, 600, 800, 3, 64)
  338.        texture{pared}
  339. } */
  340.  
  341.  
  342. object{escalera_80Yx105Z_triple
  343.        texture{pared}
  344. }
  345.  
  346. plane{z,0 pigment{checker color Red, color Yellow} scale<100,100,100> translate<0,0,20>}
  347. plane{y,0 pigment{checker color Red, color Yellow} scale<100,100,100>}
  348.  
  349.